home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / bbs / termv4.6 / extras / source / term-source.lha / AmigaGuide.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-18  |  8.5 KB  |  422 lines
  1. /*
  2. **    AmigaGuide.c
  3. **
  4. **    AmigaGuide support routines
  5. **
  6. **    Copyright © 1990-1993 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #ifndef _GLOBAL_H
  11. #include "Global.h"
  12. #endif
  13.  
  14.     /* Local data. */
  15.  
  16. STATIC STRPTR             ContextList[55];
  17. STATIC AMIGAGUIDECONTEXT     Context;
  18. STATIC struct NewAmigaGuide     NewGuide;
  19. STATIC struct Process        *GuideProcess;
  20. STATIC LONG             GuideContextID = CONTEXT_MAIN;
  21.  
  22.     /* GuideServer(VOID):
  23.      *
  24.      *    AmigaGuide server, handles all the signal processing.
  25.      */
  26.  
  27. STATIC VOID __saveds
  28. GuideServer(VOID)
  29. {
  30.         /* Open the help text file asynchronously... */
  31.  
  32.     if(Context = OpenAmigaGuideAsync(&NewGuide,TAG_DONE))
  33.     {
  34.         ULONG    GuideMask,
  35.             Signals;
  36.         BOOL    Done = FALSE;
  37.  
  38.             /* Pick up the signal notification mask. */
  39.  
  40.         GuideMask = AmigaGuideSignal(Context);
  41.  
  42.             /* Clear the context stack. */
  43.  
  44.         SetAmigaGuideContext(Context,0,TAG_DONE);
  45.  
  46.             /* Flag the main process to continue. */
  47.  
  48.         Signal(ThisProcess,SIG_HANDSHAKE);
  49.  
  50.             /* Go into input loop. */
  51.  
  52.         do
  53.         {
  54.                 /* Wait for a signal... */
  55.  
  56.             Signals = Wait(SIG_KILL | GuideMask);
  57.  
  58.                 /* Are we to quit? */
  59.  
  60.             if(Signals & SIG_KILL)
  61.                 Done = TRUE;
  62.  
  63.                 /* Process icoming AmigaGuide messages. */
  64.  
  65.             if(Signals & GuideMask)
  66.             {
  67.                 struct AmigaGuideMsg *GuideMessage;
  68.  
  69.                 while(GuideMessage = GetAmigaGuideMsg(Context))
  70.                     ReplyAmigaGuideMsg(GuideMessage);
  71.             }
  72.         }
  73.         while(!Done);
  74.  
  75.             /* Close the help text file. */
  76.  
  77.         CloseAmigaGuide(Context);
  78.     }
  79.  
  80.         /* Lock & quit. */
  81.  
  82.     Forbid();
  83.  
  84.     GuideProcess = NULL;
  85.  
  86.     Signal(ThisProcess,SIG_HANDSHAKE);
  87. }
  88.  
  89.     /* GuideLaunch(LONG ContextID):
  90.      *
  91.      *    Launch the AmigaGuide help file server.
  92.      */
  93.  
  94. STATIC BOOL
  95. GuideLaunch(LONG ContextID)
  96. {
  97.         /* Is the main program running and is this the
  98.          * main program to make the call?
  99.          */
  100.  
  101.     if(Window && FindTask(NULL) == ThisProcess)
  102.     {
  103.             /* Is the help file server already running? */
  104.  
  105.         if(!GuideProcess)
  106.         {
  107.             if(!AmigaGuideBase)
  108.                 AmigaGuideBase = OpenLibrary("amigaguide.library",0);
  109.  
  110.             if(AmigaGuideBase)
  111.             {
  112.                 BOOL IsValidFile = TRUE;
  113.  
  114.                     /* Do we have a valid AmigaGuide file name? */
  115.  
  116.                 if(Config -> PathConfig -> HelpFile[0])
  117.                 {
  118.                     if(!GetFileSize(Config -> PathConfig -> HelpFile))
  119.                         IsValidFile = FALSE;
  120.                 }
  121.                 else
  122.                     IsValidFile = FALSE;
  123.  
  124.                     /* Do we have a valid AmigaGuide file name? */
  125.  
  126.                 if(!IsValidFile)
  127.                 {
  128.                         /* Don't pop up the file requester if any
  129.                          * time-critical services are currently running!
  130.                          */
  131.  
  132.                     if(ContextID == CONTEXT_TRANSFER || ContextID == CONTEXT_DIAL)
  133.                     {
  134.                         DisplayBeep(Window -> WScreen);
  135.  
  136.                         return(FALSE);
  137.                     }
  138.                     else
  139.                     {
  140.                         struct FileRequester    *FileRequest;
  141.                         UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  142.                                      DummyName[40];
  143.  
  144.                             /* Provide a default name if necessary. */
  145.  
  146.                         if(!Config -> PathConfig -> HelpFile[0])
  147.                             strcpy(Config -> PathConfig -> HelpFile,"PROGDIR:term.guide");
  148.  
  149.                             /* Block the windows. */
  150.  
  151.                         BlockWindows();
  152.  
  153.                             /* Get file and path name. */
  154.  
  155.                         strcpy(DummyBuffer,Config -> PathConfig -> HelpFile);
  156.  
  157.                         if(DummyBuffer[0])
  158.                         {
  159.                             STRPTR DummyChar;
  160.  
  161.                             if(FilePart(DummyBuffer) == DummyBuffer)
  162.                             {
  163.                                 strcpy(DummyName,DummyBuffer);
  164.  
  165.                                 DummyBuffer[0] = 0;
  166.                             }
  167.                             else
  168.                             {
  169.                                 strcpy(DummyName,FilePart(DummyBuffer));
  170.  
  171.                                 DummyChar = PathPart(DummyBuffer);
  172.  
  173.                                 *DummyChar = 0;
  174.                             }
  175.                         }
  176.                         else
  177.                             DummyName[0] = 0;
  178.  
  179.                             /* Get the help text file name. */
  180.  
  181.                         if(FileRequest = GetFile(Window,LocaleString(MSG_PATHPANEL_SELECT_HELP_FILE_TXT),DummyBuffer,DummyName,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  182.                         {
  183.                             if(GetFileSize(DummyBuffer))
  184.                             {
  185.                                 strcpy(Config -> PathConfig -> HelpFile,DummyBuffer);
  186.  
  187.                                 IsValidFile = TRUE;
  188.                             }
  189.  
  190.                             FreeAslRequest(FileRequest);
  191.                         }
  192.  
  193.                             /* Release the windows... */
  194.  
  195.                         ReleaseWindows();
  196.                     }
  197.                 }
  198.  
  199.                     /* Do we finally have a valid file name? */
  200.  
  201.                 if(IsValidFile)
  202.                 {
  203.                     STATIC LONG NodeTable[] =
  204.                     {
  205.                         MSG_TERMAMIGAGUIDE_NODE_00_TXT,
  206.                         MSG_TERMAMIGAGUIDE_NODE_01_TXT,
  207.                         MSG_TERMAMIGAGUIDE_NODE_02_TXT,
  208.                         MSG_TERMAMIGAGUIDE_NODE_03_TXT,
  209.                         MSG_TERMAMIGAGUIDE_NODE_04_TXT,
  210.                         MSG_TERMAMIGAGUIDE_NODE_05_TXT,
  211.                         MSG_TERMAMIGAGUIDE_NODE_06_TXT,
  212.                         MSG_TERMAMIGAGUIDE_NODE_07_TXT,
  213.                         MSG_TERMAMIGAGUIDE_NODE_08_TXT,
  214.                         MSG_TERMAMIGAGUIDE_NODE_09_TXT,
  215.                         MSG_TERMAMIGAGUIDE_NODE_10_TXT,
  216.                         MSG_TERMAMIGAGUIDE_NODE_11_TXT,
  217.                         MSG_TERMAMIGAGUIDE_NODE_12_TXT,
  218.                         MSG_TERMAMIGAGUIDE_NODE_13_TXT,
  219.                         MSG_TERMAMIGAGUIDE_NODE_14_TXT,
  220.                         MSG_TERMAMIGAGUIDE_NODE_15_TXT,
  221.                         MSG_TERMAMIGAGUIDE_NODE_16_TXT,
  222.                         MSG_TERMAMIGAGUIDE_NODE_17_TXT,
  223.                         MSG_TERMAMIGAGUIDE_NODE_18_TXT,
  224.                         MSG_TERMAMIGAGUIDE_NODE_19_TXT,
  225.                         MSG_TERMAMIGAGUIDE_NODE_20_TXT,
  226.                         MSG_TERMAMIGAGUIDE_NODE_21_TXT,
  227.                         MSG_TERMAMIGAGUIDE_NODE_22_TXT,
  228.                         MSG_TERMAMIGAGUIDE_NODE_23_TXT,
  229.                         MSG_TERMAMIGAGUIDE_NODE_24_TXT,
  230.                         MSG_TERMAMIGAGUIDE_NODE_25_TXT,
  231.                         MSG_TERMAMIGAGUIDE_NODE_26_TXT,
  232.                         MSG_TERMAMIGAGUIDE_NODE_27_TXT,
  233.                         MSG_TERMAMIGAGUIDE_NODE_28_TXT,
  234.                         MSG_TERMAMIGAGUIDE_NODE_29_TXT,
  235.                         MSG_TERMAMIGAGUIDE_NODE_30_TXT,
  236.                         MSG_TERMAMIGAGUIDE_NODE_31_TXT,
  237.                         MSG_TERMAMIGAGUIDE_NODE_32_TXT,
  238.                         MSG_TERMAMIGAGUIDE_NODE_33_TXT,
  239.                         MSG_TERMAMIGAGUIDE_NODE_34_TXT,
  240.                         MSG_TERMAMIGAGUIDE_NODE_35_TXT,
  241.                         MSG_TERMAMIGAGUIDE_NODE_36_TXT,
  242.                         MSG_TERMAMIGAGUIDE_NODE_37_TXT,
  243.                         MSG_TERMAMIGAGUIDE_NODE_38_TXT,
  244.                         MSG_TERMAMIGAGUIDE_NODE_39_TXT,
  245.                         MSG_TERMAMIGAGUIDE_NODE_40_TXT,
  246.                         MSG_TERMAMIGAGUIDE_NODE_41_TXT,
  247.                         MSG_TERMAMIGAGUIDE_NODE_42_TXT,
  248.                         MSG_TERMAMIGAGUIDE_NODE_43_TXT,
  249.                         MSG_TERMAMIGAGUIDE_NODE_44_TXT,
  250.                         MSG_TERMAMIGAGUIDE_NODE_45_TXT,
  251.                         MSG_TERMAMIGAGUIDE_NODE_46_TXT,
  252.                         MSG_TERMAMIGAGUIDE_NODE_47_TXT,
  253.                         MSG_TERMAMIGAGUIDE_NODE_48_TXT,
  254.                         MSG_TERMAMIGAGUIDE_NODE_49_TXT,
  255.                         MSG_TERMAMIGAGUIDE_NODE_50_TXT,
  256.                         MSG_TERMAMIGAGUIDE_NODE_51_TXT,
  257.                         MSG_TERMAMIGAGUIDE_NODE_52_TXT,
  258.                         MSG_TERMAMIGAGUIDE_NODE_53_TXT,
  259.  
  260.                         -1
  261.                     };
  262.  
  263.                         /* Provide the context node names (note: language
  264.                          * specific!).
  265.                          */
  266.  
  267.                     LocalizeStringTable(ContextList,NodeTable);
  268.  
  269.                         /* Clear the instance. */
  270.  
  271.                     memset(&NewGuide,0,sizeof(struct NewAmigaGuide));
  272.  
  273.                         /* Fill in the structure. */
  274.  
  275.                     NewGuide . nag_BaseName        = "termHelp";
  276.                     NewGuide . nag_Name        = Config -> PathConfig -> HelpFile;
  277.                     NewGuide . nag_ClientPort    = "TERM_HELP";
  278.                     NewGuide . nag_Context        = ContextList;
  279.                     NewGuide . nag_Screen        = Window -> WScreen;
  280.  
  281.                         /* Launch the server process and
  282.                          * wait for reply.
  283.                          */
  284.  
  285.                     Forbid();
  286.  
  287.                     if(GuideProcess = CreateNewProcTags(
  288.                         NP_Entry,    GuideServer,
  289.                         NP_Name,    "term AmigaGuide Process",
  290.                     TAG_DONE))
  291.                     {
  292.                         ClrSignal(SIG_HANDSHAKE);
  293.  
  294.                         Wait(SIG_HANDSHAKE);
  295.                     }
  296.  
  297.                     Permit();
  298.                 }
  299.             }
  300.         }
  301.  
  302.             /* Pop the main screen to the front if necessary. */
  303.  
  304.         if(GuideProcess)
  305.         {
  306.             ScreenToFront(Window -> WScreen);
  307.  
  308.             return(TRUE);
  309.         }
  310.         else
  311.         {
  312.             if(AmigaGuideBase)
  313.             {
  314.                 CloseLibrary(AmigaGuideBase);
  315.  
  316.                 AmigaGuideBase = NULL;
  317.             }
  318.  
  319.             DisplayBeep(Window -> WScreen);
  320.  
  321.             return(FALSE);
  322.         }
  323.     }
  324.     else
  325.     {
  326.         if(GuideProcess && Window)
  327.         {
  328.             ScreenToFront(Window -> WScreen);
  329.  
  330.             return(TRUE);
  331.         }
  332.         else
  333.             return(FALSE);
  334.     }
  335. }
  336.  
  337.     /* GuideCleanup():
  338.      *
  339.      *    Terminate the AmigaGuide server and free the
  340.      *    associated resources.
  341.      */
  342.  
  343. VOID
  344. GuideCleanup()
  345. {
  346.     if(GuideProcess)
  347.     {
  348.         Forbid();
  349.  
  350.         Signal(GuideProcess,SIG_KILL);
  351.  
  352.         ClrSignal(SIG_HANDSHAKE);
  353.  
  354.         Wait(SIG_HANDSHAKE);
  355.  
  356.         Permit();
  357.     }
  358.  
  359.     if(AmigaGuideBase)
  360.     {
  361.         CloseLibrary(AmigaGuideBase);
  362.  
  363.         AmigaGuideBase = NULL;
  364.     }
  365. }
  366.  
  367.     /* GuideContext(LONG NewContextID):
  368.      *
  369.      *    Set the global AmigaGuide context.
  370.      */
  371.  
  372. VOID
  373. GuideContext(LONG NewContextID)
  374. {
  375.     GuideContextID = NewContextID;
  376. }
  377.  
  378. ULONG __saveds __asm
  379. GuideSetupHook(REG(a0) struct Hook *Hook,REG(a1) struct IBox *Bounds,REG(a2) HelpMsg *HelpMessage)
  380. {
  381.     if(GuideLaunch(GuideContextID))
  382.     {
  383.         SetAmigaGuideContext(Context,GuideContextID,TAG_DONE);
  384.         SendAmigaGuideContext(Context,TAG_DONE);
  385.  
  386.         return(TRUE);
  387.     }
  388.     else
  389.         return(FALSE);
  390. }
  391.  
  392.     /* GuideSetup():
  393.      *
  394.      *    Try to display the currently selected AmigaGuide
  395.      *    help text.
  396.      */
  397.  
  398. VOID
  399. GuideSetup()
  400. {
  401.     if(GuideLaunch(GuideContextID))
  402.     {
  403.         SetAmigaGuideContext(Context,GuideContextID,TAG_DONE);
  404.         SendAmigaGuideContext(Context,TAG_DONE);
  405.     }
  406. }
  407.  
  408.     /* GuideDisplay(LONG ContextID):
  409.      *
  410.      *    Try to display an AmigaGuide help text.
  411.      */
  412.  
  413. VOID
  414. GuideDisplay(LONG ContextID)
  415. {
  416.     if(GuideLaunch(ContextID))
  417.     {
  418.         SetAmigaGuideContext(Context,ContextID,TAG_DONE);
  419.         SendAmigaGuideContext(Context,TAG_DONE);
  420.     }
  421. }
  422.